/*
 * jQuery treetable Plugin 3.2.0
 * http://ludo.cubicphuse.nl/jquery-treetable
 *
 * Copyright 2013, Ludo van den Boom
 * Dual licensed under the MIT or GPL Version 2 licenses.
 */
import $ from 'jquery'

var Node, Tree, methods;

Node = (function () {
  function Node (row, tree, settings) {
    var parentId;

    this.row = row;
    this.tree = tree;
    this.settings = settings;

    // TODO Ensure id/parentId is always a string (not int)
    this.id = this.row.data(this.settings.nodeIdAttr);

    // TODO Move this to a setParentId function?
    parentId = this.row.data(this.settings.parentIdAttr);
    if (parentId != null && parentId !== "") {
      this.parentId = parentId;
    }

    this.treeCell = $(this.row.children(this.settings.columnElType)[this.settings.column]);
    this.expander = $(this.settings.expanderTemplate);
    this.indenter = $(this.settings.indenterTemplate);
    this.cell = $(this.settings.cellTemplate);
    this.children = [];
    this.initialized = false;
    this.treeCell.prepend(this.indenter);
    this.treeCell.wrapInner(this.cell);
  }

  Node.prototype.addChild = function (child) {
    return this.children.push(child);
  };

  Node.prototype.ancestors = function () {
    var ancestors, node;
    node = this;
    ancestors = [];
    while (node = node.parentNode()) {
      ancestors.push(node);
    }
    return ancestors;
  };

  Node.prototype.collapse = function () {
    if (this.collapsed()) {
      return this;
    }

    this.row.removeClass("expanded").addClass("collapsed");

    this._hideChildren();
    this.expander.attr("title", this.settings.stringExpand);

    if (this.initialized && this.settings.onNodeCollapse != null) {
      this.settings.onNodeCollapse.apply(this);
    }

    return this;
  };

  Node.prototype.collapsed = function () {
    return this.row.hasClass("collapsed");
  };

  // TODO destroy: remove event handlers, expander, indenter, etc.

  Node.prototype.expand = function () {
    if (this.expanded()) {
      return this;
    }

    this.row.removeClass("collapsed").addClass("expanded");

    if (this.initialized && this.settings.onNodeExpand != null) {
      this.settings.onNodeExpand.apply(this);
    }

    if ($(this.row).is(":visible")) {
      this._showChildren();
    }

    this.expander.attr("title", this.settings.stringCollapse);

    return this;
  };

  Node.prototype.expanded = function () {
    return this.row.hasClass("expanded");
  };

  Node.prototype.hide = function () {
    this._hideChildren();
    this.row.hide();
    return this;
  };

  Node.prototype.isBranchNode = function () {
    if (this.children.length > 0 || this.row.data(this.settings.branchAttr) === true) {
      return true;
    } else {
      return false;
    }
  };

  Node.prototype.updateBranchLeafClass = function () {
    this.row.removeClass('branch');
    this.row.removeClass('leaf');
    this.row.addClass(this.isBranchNode() ? 'branch' : 'leaf');
  };

  Node.prototype.level = function () {
    return this.ancestors().length;
  };

  Node.prototype.parentNode = function () {
    if (this.parentId != null) {
      return this.tree[this.parentId];
    } else {
      return null;
    }
  };

  Node.prototype.removeChild = function (child) {
    var i = $.inArray(child, this.children);
    return this.children.splice(i, 1)
  };

  Node.prototype.render = function () {
    var handler,
        settings = this.settings,
        target;

    if (settings.expandable === true && this.isBranchNode()) {
      handler = function (e) {
        $(this).parents("table").treetable("node", $(this).parents("tr").data(settings.nodeIdAttr)).toggle();
        return e.preventDefault();
      };

      this.indenter.html(this.expander);
      target = settings.clickableNodeNames === true ? this.treeCell : this.expander;

      target.off("click.treetable").on("click.treetable", handler);
      target.off("keydown.treetable").on("keydown.treetable", function (e) {
        if (e.keyCode == 13) {
          handler.apply(this, [e]);
        }
      });
    }

    this.indenter[0].style.paddingLeft = "" + (this.level() * settings.indent) + "px";

    return this;
  };

  Node.prototype.reveal = function () {
    if (this.parentId != null) {
      this.parentNode().reveal();
    }
    return this.expand();
  };

  Node.prototype.setParent = function (node) {
    if (this.parentId != null) {
      this.tree[this.parentId].removeChild(this);
    }
    this.parentId = node.id;
    this.row.data(this.settings.parentIdAttr, node.id);
    return node.addChild(this);
  };

  Node.prototype.show = function () {
    if (!this.initialized) {
      this._initialize();
    }
    this.row.show();
    if (this.expanded()) {
      this._showChildren();
    }
    return this;
  };

  Node.prototype.toggle = function () {
    if (this.expanded()) {
      this.collapse();
    } else {
      this.expand();
    }
    return this;
  };

  Node.prototype._hideChildren = function () {
    var child, _i, _len, _ref, _results;
    _ref = this.children;
    _results = [];
    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
      child = _ref[_i];
      _results.push(child.hide());
    }
    return _results;
  };

  Node.prototype._initialize = function () {
    var settings = this.settings;

    this.render();

    if (settings.expandable === true && settings.initialState === "collapsed") {
      this.collapse();
    } else {
      this.expand();
    }

    if (settings.onNodeInitialized != null) {
      settings.onNodeInitialized.apply(this);
    }

    return this.initialized = true;
  };

  Node.prototype._showChildren = function () {
    var child, _i, _len, _ref, _results;
    _ref = this.children;
    _results = [];
    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
      child = _ref[_i];
      _results.push(child.show());
    }
    return _results;
  };

  return Node;
})();

Tree = (function () {
  function Tree (table, settings) {
    this.table = table;
    this.settings = settings;
    this.tree = {};

    // Cache the nodes and roots in simple arrays for quick access/iteration
    this.nodes = [];
    this.roots = [];
  }

  Tree.prototype.collapseAll = function () {
    var node, _i, _len, _ref, _results;
    _ref = this.nodes;
    _results = [];
    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
      node = _ref[_i];
      _results.push(node.collapse());
    }
    return _results;
  };

  Tree.prototype.expandAll = function () {
    var node, _i, _len, _ref, _results;
    _ref = this.nodes;
    _results = [];
    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
      node = _ref[_i];
      _results.push(node.expand());
    }
    return _results;
  };

  Tree.prototype.findLastNode = function (node) {
    if (node.children.length > 0) {
      return this.findLastNode(node.children[node.children.length - 1]);
    } else {
      return node;
    }
  };

  Tree.prototype.loadRows = function (rows) {
    var node, row, i;

    if (rows != null) {
      for (i = 0; i < rows.length; i++) {
        row = $(rows[i]);

        if (row.data(this.settings.nodeIdAttr) != null) {
          node = new Node(row, this.tree, this.settings);
          this.nodes.push(node);
          this.tree[node.id] = node;

          if (node.parentId != null && this.tree[node.parentId]) {
            this.tree[node.parentId].addChild(node);
          } else {
            this.roots.push(node);
          }
        }
      }
    }

    for (i = 0; i < this.nodes.length; i++) {
      node = this.nodes[i].updateBranchLeafClass();
    }

    return this;
  };

  Tree.prototype.move = function (node, destination) {
    // Conditions:
    // 1: +node+ should not be inserted as a child of +node+ itself.
    // 2: +destination+ should not be the same as +node+'s current parent (this
    //    prevents +node+ from being moved to the same location where it already
    //    is).
    // 3: +node+ should not be inserted in a location in a branch if this would
    //    result in +node+ being an ancestor of itself.
    var nodeParent = node.parentNode();
    if (node !== destination && destination.id !== node.parentId && $.inArray(node, destination.ancestors()) === -1) {
      node.setParent(destination);
      this._moveRows(node, destination);

      // Re-render parentNode if this is its first child node, and therefore
      // doesn't have the expander yet.
      if (node.parentNode().children.length === 1) {
        node.parentNode().render();
      }
    }

    if (nodeParent) {
      nodeParent.updateBranchLeafClass();
    }
    if (node.parentNode()) {
      node.parentNode().updateBranchLeafClass();
    }
    node.updateBranchLeafClass();
    return this;
  };

  Tree.prototype.removeNode = function (node) {
    // Recursively remove all descendants of +node+
    this.unloadBranch(node);

    // Remove node from DOM (<tr>)
    node.row.remove();

    // Remove node from parent children list
    if (node.parentId != null) {
      node.parentNode().removeChild(node);
    }

    // Clean up Tree object (so Node objects are GC-ed)
    delete this.tree[node.id];
    this.nodes.splice($.inArray(node, this.nodes), 1);

    return this;
  }

  Tree.prototype.render = function () {
    var root, _i, _len, _ref;
    _ref = this.roots;
    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
      root = _ref[_i];

      // Naming is confusing (show/render). I do not call render on node from
      // here.
      root.show();
    }
    return this;
  };

  Tree.prototype.sortBranch = function (node, sortFun) {
    // First sort internal array of children
    node.children.sort(sortFun);

    // Next render rows in correct order on page
    this._sortChildRows(node);

    return this;
  };

  Tree.prototype.unloadBranch = function (node) {
    // Use a copy of the children array to not have other functions interfere
    // with this function if they manipulate the children array
    // (eg removeNode).
    var children = node.children.slice(0),
        i;

    for (i = 0; i < children.length; i++) {
      this.removeNode(children[i]);
    }

    // Reset node's collection of children
    node.children = [];

    node.updateBranchLeafClass();

    return this;
  };

  Tree.prototype._moveRows = function (node, destination) {
    var children = node.children, i;

    node.row.insertAfter(destination.row);
    node.render();

    // Loop backwards through children to have them end up on UI in correct
    // order (see #112)
    for (i = children.length - 1; i >= 0; i--) {
      this._moveRows(children[i], node);
    }
  };

  // Special _moveRows case, move children to itself to force sorting
  Tree.prototype._sortChildRows = function (parentNode) {
    return this._moveRows(parentNode, parentNode);
  };

  return Tree;
})();

// jQuery Plugin
methods = {
  init: function (options, force) {
    var settings;

    settings = $.extend({
      branchAttr: "ttBranch",
      clickableNodeNames: false,
      column: 0,
      columnElType: "td", // i.e. 'td', 'th' or 'td,th'
      expandable: false,
      expanderTemplate: "<a href='#'>&nbsp;</a>",
      indent: 19,
      indenterTemplate: "<span class='indenter'></span>",
      cellTemplate: '',
      initialState: "collapsed",
      nodeIdAttr: "ttId", // maps to data-tt-id
      parentIdAttr: "ttParentId", // maps to data-tt-parent-id
      stringExpand: "Expand",
      stringCollapse: "Collapse",

      // Events
      onInitialized: null,
      onNodeCollapse: null,
      onNodeExpand: null,
      onNodeInitialized: null
    }, options);

    return this.each(function () {
      var el = $(this), tree;

      if (force || el.data("treetable") === undefined) {
        tree = new Tree(this, settings);
        tree.loadRows(this.rows).render();

        el.addClass("treetable").data("treetable", tree);

        if (settings.onInitialized != null) {
          settings.onInitialized.apply(tree);
        }
      }

      return el;
    });
  },

  destroy: function () {
    return this.each(function () {
      return $(this).removeData("treetable").removeClass("treetable");
    });
  },

  collapseAll: function () {
    this.data("treetable").collapseAll();
    return this;
  },

  collapseNode: function (id) {
    var node = this.data("treetable").tree[id];

    if (node) {
      node.collapse();
    } else {
      throw new Error("Unknown node '" + id + "'");
    }

    return this;
  },

  expandAll: function () {
    this.data("treetable").expandAll();
    return this;
  },

  expandNode: function (id) {
    var node = this.data("treetable").tree[id];

    if (node) {
      if (!node.initialized) {
        node._initialize();
      }

      node.expand();
    } else {
      throw new Error("Unknown node '" + id + "'");
    }

    return this;
  },

  loadBranch: function (node, rows) {
    var settings = this.data("treetable").settings,
        tree = this.data("treetable").tree;

    // TODO Switch to $.parseHTML
    rows = $(rows);

    if (node == null) { // Inserting new root nodes
      this.append(rows);
    } else {
      var lastNode = this.data("treetable").findLastNode(node);
      rows.insertAfter(lastNode.row);
    }

    this.data("treetable").loadRows(rows);

    // Make sure nodes are properly initialized
    rows.filter("tr").each(function () {
      tree[$(this).data(settings.nodeIdAttr)].show();
    });

    if (node != null) {
      // Re-render parent to ensure expander icon is shown (#79)
      node.render().expand();
    }

    return this;
  },

  move: function (nodeId, destinationId) {
    var destination, node;

    node = this.data("treetable").tree[nodeId];
    destination = this.data("treetable").tree[destinationId];
    this.data("treetable").move(node, destination);

    return this;
  },

  node: function (id) {
    return this.data("treetable").tree[id];
  },

  removeNode: function (id) {
    var node = this.data("treetable").tree[id];

    if (node) {
      this.data("treetable").removeNode(node);
    } else {
      throw new Error("Unknown node '" + id + "'");
    }

    return this;
  },

  reveal: function (id) {
    var node = this.data("treetable").tree[id];

    if (node) {
      node.reveal();
    } else {
      throw new Error("Unknown node '" + id + "'");
    }

    return this;
  },

  sortBranch: function (node, columnOrFunction) {
    var settings = this.data("treetable").settings,
        prepValue,
        sortFun;

    columnOrFunction = columnOrFunction || settings.column;
    sortFun = columnOrFunction;

    if ($.isNumeric(columnOrFunction)) {
      sortFun = function (a, b) {
        var extractValue, valA, valB;

        extractValue = function (node) {
          var val = node.row.find("td:eq(" + columnOrFunction + ")").text();
          // Ignore trailing/leading whitespace and use uppercase values for
          // case insensitive ordering
          return $.trim(val).toUpperCase();
        }

        valA = extractValue(a);
        valB = extractValue(b);

        if (valA < valB) return -1;
        if (valA > valB) return 1;
        return 0;
      };
    }

    this.data("treetable").sortBranch(node, sortFun);
    return this;
  },

  unloadBranch: function (node) {
    this.data("treetable").unloadBranch(node);
    return this;
  }
};

$.fn.treetable = function (method) {
  if (methods[method]) {
    return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
  } else if (typeof method === 'object' || !method) {
    return methods.init.apply(this, arguments);
  } else {
    return $.error("Method " + method + " does not exist on jQuery.treetable");
  }
};